# -*- coding: utf-8 -*-
"""
#-------------------------------------------------------------------------------
# Nom:         traitementResultat
#
# Auteur:      Alain Gauthier
#
# Créé le:     16/08/2013
# Copyright:   (c) eaucéa 2014
# Licence:     GNU Public Licence (GPL)

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

Analyse des résultats : création d'affichages et génération de fichiers d'export

Ce script doit être lancé depuis l'interface du plugin 'ModelePluieDebit' sous QGIS

#-------------------------------------------------------------------------------
"""

# modules système
import os
import csv
import datetime
# modules externes
import numpy as np
# modules GUI
from PyQt4 import QtCore, QtGui
# modules internes
import affChroniques
import analyseChroniques
import typeCritereNash

# fichier d'export des paramètres optimisés des modèles GR2M
__fichier_exportXGR__ = 'paramOptimGR.csv'
__fichier_exportXsimuGR__ = 'paramSimuGR.csv'
__fichier_exportQsimu__='Qsimu.csv'
__fichier_exportStatsimuGR__= 'StatsSimu.csv'

try:
    _fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
    _fromUtf8 = lambda s: s

class TraitementResultat(object):
    """
    Classe servant à générer des affichage et des fichiers d'export pour l'analyse des résultats du modèle
    """

    def __init__(self):
        """
        Constructeur
        """

    #--------------------------------------------------------------------------#

    def exporter_XGR_station(self,Achemin,AdicoStations,AresultatOptim,AcritereOptim):
        """
        Export des paramètres optimisés du modèle GR calculé pour chaque station de mesure
        """
        # nom de fichier fixé
        nomfichier = os.path.join(Achemin,__fichier_exportXGR__)

        # champs du fichier
        champs = ['idStation', 'id_BV', 'X1', 'X2', 'X3', 'X4']
        for critere in typeCritereNash.listeCritereNash:
            champs.append(critere)
        fid = open (nomfichier, 'w')
        try:
            # sérialisation et écriture des données
            csv_writer = csv.writer(fid, champs, delimiter=';',quoting=csv.QUOTE_NONE)
            # écriture des champs
            csv_writer.writerow(champs)

            for idStation in AresultatOptim:
                ligne=[]
                ligne.append(str(idStation))
                ligne.append(str(AdicoStations[idStation]['id_BV']))
                ligne.extend(AresultatOptim[idStation])
                ligne.extend(AcritereOptim[idStation])
                # écriture
                csv_writer.writerow(ligne)
        finally:
            fid.close()

    #--------------------------------------------------------------------------#

    def exporter_XGR_simu(self,Achemin,AresultatSimu):
        """
        Export des paramètres calculés par le modèle régional GR obtenus lors des simulations
        """
        # nom de fichier fixé
        nomfichier = os.path.join(Achemin,__fichier_exportXsimuGR__)

        # champs du fichier
        champs = ['id_BV', 'X1', 'X2', 'X3', 'X4']

        fid = open (nomfichier, 'w')
        try:
            # sérialisation et écriture des données
            csv_writer = csv.writer(fid, champs, delimiter=';',quoting=csv.QUOTE_NONE)
            # écriture des champs
            csv_writer.writerow(champs)

            for id_bv in AresultatSimu:
                ligne=[]
                ligne.append(str(id_bv))
                ligne.extend(AresultatSimu[id_bv]['xParam'])
                # écriture
                csv_writer.writerow(ligne)
        finally:
            fid.close()

    #--------------------------------------------------------------------------#

    def exporter_Qsimu(self,Achemin, AresultatSimu):
        """
        Export des chroniques de débit simulés dans un fichier CSV
        """
        # test sur les données d'entrée
        if len(AresultatSimu.keys())==0:
            # pas de résultat
            return

        # débits en m3/s
        Qsimu=dict()

        # nom de fichier fixé
        nomfichier = os.path.join(Achemin,__fichier_exportQsimu__)

        # champs du fichier
        champs = ['date']
        tps=None
        lmax=0
        for id_bv in AresultatSimu:
            champs.append(str(id_bv))
            # dates
            if tps is None:
                tps=np.array(AresultatSimu[id_bv]['pluie']['temps'])
                lmax=min(len(tps),len(AresultatSimu[id_bv]['Qsimu']))
            # débit en m3/s
            Qsimu[str(id_bv)]=np.array(analyseChroniques.debit_enM3S(AresultatSimu[id_bv]['Qsimu'],
                                                                     tps,
                                                                     AresultatSimu[id_bv]['aire']))

        fid = open (nomfichier, 'w')
        try:
            # sérialisation et écriture des données
            csv_writer = csv.writer(fid, champs, delimiter=';',quoting=csv.QUOTE_NONE)
            # écriture des champs
            csv_writer.writerow(champs)

            for idate in range(lmax):
                ligne=[]
                # date
                ligne.append(str(tps[idate]))
                # débit simulé
                for idchamp in range(1,len(champs)):
                    ligne.append(Qsimu[champs[idchamp]][idate])
                # écriture
                csv_writer.writerow(ligne)
        finally:
            fid.close()

    #--------------------------------------------------------------------------#

    def exporter_Stats(self,Achemin, AstatSimu,AresultatSimu):
        """
        Export des paramètres calculés par le modèle régional GR obtenus lors des simulations
        """
        # nom de fichier fixé
        nomfichier = os.path.join(Achemin,__fichier_exportStatsimuGR__)

        # champs du fichier
        champs = ['id_BV', 'Module', 'QMNA5','aire']

        fid = open (nomfichier, 'w')
        try:
            # sérialisation et écriture des données
            csv_writer = csv.writer(fid, champs, delimiter=';',quoting=csv.QUOTE_NONE)
            # écriture des champs
            csv_writer.writerow(champs)

            for id_bv in AstatSimu:
                ligne=[]
                ligne.append(str(id_bv))
                ligne.append(AstatSimu[id_bv]['Module'])
                ligne.append(AstatSimu[id_bv]['QMNA5'])
                ligne.append(AresultatSimu[id_bv]['aire'])
                # écriture
                csv_writer.writerow(ligne)
        finally:
            fid.close()

    #--------------------------------------------------------------------------#

    def creerAffichage(self,Aid_bv,Aid_station,AoptionsAff,AresultatSimu,AchroniquesQmesure):
        """
        création et affichage des graphes de résultat de simulation. Ouvre une nouvelle fenêtre
        Aid_bv             : id du bv simulé à afficher
        Aid_station        : id de la station de débit mesuré à afficher
        AoptionsAff        : (pluie,evapo,Qsimulé,Qmesuré) tuple des options du graphe (True/False)
        AresultatSimu      : résultats des simulations
        AchroniquesQmesure : données mesurées
        ATTENTION : les débit sont calculés en mm. Il faut les afficher en m3/s
        """

        # données d'affichage
        # temps en abscisse
        tps=np.array(AresultatSimu[Aid_bv]['pluie']['temps'])
        # pluie en mm
        pluie=np.array(AresultatSimu[Aid_bv]['pluie']['valeur'])
        # evapotranspiration en mm
        evapo=np.array(AresultatSimu[Aid_bv]['evapo']['valeur'])
        # Q simulé
        Qsimu=np.array(analyseChroniques.debit_enM3S(AresultatSimu[Aid_bv]['Qsimu'],
                                            tps,
                                            AresultatSimu[Aid_bv]['aire']))
        # Q mesuré
        Qmesu=[]
        if AoptionsAff[3]:
            Qmesu=np.array(analyseChroniques.debit_enM3S(AchroniquesQmesure[Aid_station]['valeur'],
                                                tps,
                                                AresultatSimu[Aid_bv]['aire']))
            Qmesu[Qmesu<=0]=None
        # création de l'affichage
        exemple = affChroniques.chroniqueMPL(None,
                                             Aid_bv,
                                             AoptionsAff,
                                             tps,
                                             pluie,
                                             evapo,
                                             Qsimu,
                                             Qmesu)
        exemple.show()
        exemple.exec_()

    #--------------------------------------------------------------------------#
    #--------------------------------------------------------------------------#

if __name__ == '__main__':
    raise EnvironmentError("module devant être exécuté sous console/extension python QGIS")
